#ifndef CTreeXH
#define CTreeXH
//---------------------------------------------------------------------------
#include "Outils.h"
// Include Borland
#include <SysUtils.hpp>
#include <Controls.hpp>
#include <Classes.hpp>
#include <Forms.hpp>
#include <ComCtrls.hpp>
#include <dsgnintf.hpp>
#include <dbgrids.hpp>
#include <db.hpp>
#include <dbcgrids.hpp>
#include <map>
// Include Paquet
#include "CForm.h"
#include "CMForm.h"
//---------------------------------------------------------------------------
#define WM_SETSELMENU  ( WM_APP + 337)
#define WM_RETURN      ( WM_APP + 338)
#define WM_NEXT        ( WM_APP + 339)
#define WM_PRIOR       ( WM_APP + 340)
#define WM_SCRSETFOCUS ( WM_APP + 341)
//---------------------------------------------------------------------------
#define SCR_CURELMT     0
#define SCR_MENU        1
#define SCR_SAISIE_M    2
#define SCR_AFFICH_M    3
#define SCR_EDITIO_M    4
#define SCR_COURRI_M    5
#define SCR_LISTE       6
#define SCR_SAISIE_L    7
#define SCR_AFFICH_L    8
#define SCR_EDITIO_L    9
#define SCR_COURRI_L   10
//---------------------------------------------------------------------------
#define IS_LISTE(x)         (x==SCR_LISTE  )
#define IS_CURRENTELEM(x)   (x==SCR_CURELMT)
#define IS_MENULISTE(x)     (x==SCR_LISTE  )
#define IS_MENU_GEN(x)     ((x==SCR_LISTE  ) || (x==SCR_MENU    ))
#define IS_SCR_LISTE(x)    ((x>=SCR_LISTE  ) && (x<=SCR_COURRI_L))
//---------------------------------------------------------------------------
#define SCREEN_TAG( x) ((( x)->ScreenTag) & 0x0000FFFF)
#define CURRENT_CTREE  (( CTree*)( Owner))
#define MAIN_CTREE     (( CTree*)((( CTree*)Owner)->GetNodeExtraInfos( 1)->Node->TreeView))
//---------------------------------------------------------------------------
#define SCR640x480       0
#define SCR800x600       1
//---------------------------------------------------------------------------
#define VERSION      ((short)0x010a)  // Version 1.10
//---------------------------------------------------------------------------
// Macro pour accéder à la propriété Data d'un TreeNode
// comme un 'int'
#define TAG_NODE(node)  ((int)(node->Data))
//#define TAG_NODE_AF( node, value)  ( node)->Data=( void*)(value)
//---------------------------------------------------------------------------
class CTree;
class CPageControl;
class TTreeEditor;
//---------------------------------------------------------------------------
enum BUTTON_ACTION { BA_PARENT_RETURN, BA_PRIOR, BA_NEXT, BA_PRINT, BA_PREVIEW };
//---------------------------------------------------------------------------
// Modification à apporter en cas de changement de la structure
//  1 - Struct TNodeInfos (CTREE.H)
//  2 - Class CNodeInfos  (CTREE.H)
//  3 - CNodeInfos::CNodeInfos  (CTREE.CPP)
//  4 - CTree::InitStandardInfos (CTREE.CPP)
//  5 - CTree::ReadDatas  (CTREE.CPP) (si enregistrement de l'info)
//  6 - CTree::WriteDatas (CTREE.CPP) (si enregistrement de l'info)
//  7 - CTreeEditor::DisplayInformations (CTEDIT.CPP)
///////  NE PAS OUBLIER DE CHANGER DE VERSION SI AJOUT DANS ReadDatas et WriteDatas
//
typedef struct {
  AnsiString ClassName;
  AnsiString DefineName;
  AnsiString FieldName;
  AnsiString KeyField;
  AnsiString ListField;
  AnsiString Text;
  short      Mode;
  char       Level;
  bool       Enabled;
  bool       Visible;
  bool       MenuCreate;
  bool       DisplayBar;
  bool       HaveList;
  bool       EnabledInternal;
  int        Tag;
  int        TagBrother;
  int        TagParent;
  int        TagMenu;
  int        WindowStyle;
  int        Icon;
} TNodeInfos;
//---------------------------------------------------------------------------
class CNodeInfos
{
   friend CTree;

  private :
    typedef TObject inherited;

    bool        m_Visible;
    bool        m_Enabled;
    bool        m_MenuCreate;
    TTreeNode  *m_Node;
    char        m_Level;
    int         m_Tag;
    int         m_TagBrother;
    int         m_TagParent;
    int         m_TagMenu;
    AnsiString  m_Text;
    AnsiString  m_ClassName;
    AnsiString  m_DefineName;
    AnsiString  m_KeyField;
    AnsiString  m_ListField;
    AnsiString  m_FieldName;
    int         m_WindowStyle;
    short       m_Mode;
    int         m_InstanceIndex;
    bool        m_DisplayBar;
    bool        m_HaveList;
    bool        m_EnabledInternal;
    int         m_Icon;
    CTree      *m_pTree;

    __property int InstanceIndex = { read=m_InstanceIndex, write=m_InstanceIndex };

  public  :
    __fastcall  CNodeInfos( TNodeInfos &infos, CTree *pTree);
    virtual __fastcall ~CNodeInfos() { };

    __property AnsiString ClassName       = { read=m_ClassName      , write=m_ClassName       };
    __property AnsiString DefineName      = { read=m_DefineName     , write=m_DefineName      };
    __property bool       DisplayBar      = { read=m_DisplayBar     , write=m_DisplayBar      };
    __property bool       Enabled         = { read=m_Enabled        , write=m_Enabled         };
    __property AnsiString FieldName       = { read=m_FieldName      , write=m_FieldName       };
    __property bool       HaveList        = { read=m_HaveList       , write=m_HaveList        };
    __property int        Icon            = { read=m_Icon           , write=m_Icon            };
    __property AnsiString KeyField        = { read=m_KeyField       , write=m_KeyField        };
    __property AnsiString ListField       = { read=m_ListField      , write=m_ListField       };
    __property char       Level           = { read=m_Level          , write=m_Level           };
    __property bool       MenuCreate      = { read=m_MenuCreate     , write=m_MenuCreate      };
    __property short      Mode            = { read=m_Mode           , write=m_Mode            };
    __property TTreeNode *Node            = { read=m_Node           , write=m_Node            };
    __property int        Tag             = { read=m_Tag            , write=m_Tag             };
    __property int        TagBrother      = { read=m_TagBrother     , write=m_TagBrother      };
    __property int        TagMenu         = { read=m_TagMenu        , write=m_TagMenu         };
    __property int        TagParent       = { read=m_TagParent      , write=m_TagParent       };
    __property AnsiString Text            = { read=m_Text           , write=m_Text            };
    __property bool       Visible         = { read=m_Visible        , write=m_Visible         };
    __property int        WindowStyle     = { read=m_WindowStyle    , write=m_WindowStyle     };
    __property bool       EnabledInternal = { read=m_EnabledInternal, write=m_EnabledInternal };
    __property CTree     *Tree            = { read=m_pTree                                    };
};
//---------------------------------------------------------------------------
typedef CEICForm *(*TCallCreateInstance)(TComponent *Owner);
typedef void __fastcall (__closure *TChangeScreenEvent)( int nTag, TObject* Sender);
typedef void __fastcall (__closure *TChangingScreenEvent)( int nTag, TObject* Sender, bool &bAllowChange);
//---------------------------------------------------------------------------
bool __fastcall IS_ENABLED( CNodeInfos *nodeinfos);
//---------------------------------------------------------------------------
class PACKAGE_OUTILS CTree : public TCustomTreeView
{
  friend TTreeEditor;
  friend CPageControl;

  private:
    TSpeedButton *m_pbtnReturn;  // Pointeur sur le TSpeedButton du retour au menu précédent
    TSpeedButton *m_pbtnPrior;   // Pointeur sur le TSpeedButton de l'écran précédent
    TSpeedButton *m_pbtnNext;    // Pointeur sur le TSpeedButton de l'écran suivant
    TSpeedButton *m_pbtnPrint;   // Pointeur sur le TSpeedButton de l'impression
    TSpeedButton *m_pbtnPreview; // Pointeur sur le TSpeedButton de la prévisualisation

    TStrings     *m_pInstances;  // Liste des instances de DLL où l'on va rechercher les écrans
    TList        *m_pScrOpen;    // Liste des écrans actuellement chargé en mémoire
    TList        *m_pBtnAction;  // Liste des buttons actions
    CPageControl *m_pPageCtrl;   // Pointeur sur l'objet PageControl personnalisé
//    TScrollBox   *m_psbHote;     // Pointeur du le ScrollBox dans lequel s'afficheront les écrans
    short         m_nVersion;    // Numéro de version des données lus dans la DFM
    CEICForm     *m_pfrmCurrent; // Pointeur sur la form courante

    TTreeNode    *m_CommonNode;
    TList        *m_NodesInfos;
    short         m_Mask;
    AnsiString    m_szPathHeader;// Chemin d'enregistrement du HEADER de définition des nodes
    int           m_nSizeAssist; // Identificateur de la taille des écrans de l'assistant ( 640x480 ou 800x600 )
    int           m_nHeightScr;  // Hauteur des écrans de l'assistant
    int           m_nWidthScr;   // Largeur des écrans de l'assistant
    bool          m_bInitEvKey;  // Détermine si l'on a modifier les évènements de la fenêtre principale
    bool          m_bResizeable; // Détermine si les écrans sont de types redimensionnables
    bool          m_bExit;
    bool          m_bEditCTree;  // L'utilisateur a éditer l'arbre depuis l'inspecteur d'objets
    bool          m_AutoLettre;  // Indique si les écrans de l'assistant sont lettrés automatiquement
    bool          m_bCanCollapse;
    bool          m_bUseCustomIcons; // Indique s'il faut utiliser les icones personnalisées
    bool          m_bExitAss;
    bool          m_bOnCloseQueryEnCours;

    HWND          m_hwndFocusedAfterError; // Le composant possédant le focus après que CloseQuery est refusé de sortir

    TTreeNode    *m_pNodeCollapsing; // Node pour lequel, on a demandé la réduction
    CForm        *m_pMainForm;
    int           m_nLoadingTag;
    TPanel       *m_pnlPageFooter;
    TImageList   *m_lstEICIcons;  // Liste des icones des écrans EIC
    TForm **m_Splash;            //Form du splash que doit fermer l'assistant
    CTree        *m_pPushInCTree;    

//    TDataChangeEvent m_OnDataChange;

    TKeyEvent        m_pOnKeyDown;
    TKeyEvent        m_pOnKeyUp;
    TKeyPressEvent   m_pOnKeyPress;
    TNotifyEvent     m_pfncOnClose;
    TChangeScreenEvent m_pfncOnChangeScreen;
    TChangingScreenEvent m_pfncOnChangingScreen;

    // Map de l'évènement OnDataChange d'un DataSource
    typedef std::map< TDataSource*, TDataChangeEvent, std::less<TDataSource*> > TMapDataSource;
    TMapDataSource m_mapDataChange;


    //m_mapGLSolde.insert( TMapSolde::value_type( qrHIAutoID->AsInteger, curDebit-curCredit));

    //  TMapSolde::const_iterator p = m_mapGLSolde.find( qrHIAutoID->AsInteger);
//    qrHISolde->AsCurrency = (*p).second;


    // Fonctions de base d'écriture dans la dfm
    void __fastcall WriteInteger(       int  nValue, TStream *Stream);
    void __fastcall WriteChar   (      char  cValue, TStream *Stream);
    void __fastcall WriteBool   (      bool  bValue, TStream *Stream);
    void __fastcall WriteShort  (     short  nValue, TStream *Stream);
    void __fastcall WriteString ( const AnsiString &strValue, TStream *Stream);
    // Fonctions de base de lecture dans la dfm
    int        __fastcall ReadInteger(TStream *Stream);
    char       __fastcall ReadChar   (TStream *Stream);
    bool       __fastcall ReadBool   (TStream *Stream);
    short      __fastcall ReadShort  (TStream *Stream);
    AnsiString __fastcall ReadString (TStream *Stream);
    // Fonctions d'initialisation de l'application
    void __fastcall ConnectToHoteApplication(void);
    void __fastcall CreateScreensLevel      (void);
    bool __fastcall VerifyAllScreens        (void);
    void __fastcall ClearExtraDatas         (void);
    void __fastcall CreateTree              (void);
    void __fastcall CreateChildScreensLevel (TTreeNode *Node);
    void __fastcall AddMenu     (int TagParent, TNodeInfos &infos);
    void __fastcall AddChildMenu(int TagParent, TNodeInfos &infos);
    // Fonctions de services utilisées en interne
    void       __fastcall SetInternalEnableScreen( bool bEnabled, int nTag);
    TTreeNode *__fastcall FindCommonParent(TTreeNode *oldNode, TTreeNode *newNode, bool &error);
    void       __fastcall CreateButtonCaption( CNodeInfos *nodeinfos, AnsiString &strCaption);
    void       __fastcall SetTextMenu(const AnsiString &strCaption, CNodeInfos *nodeinfos);
    TControl  *__fastcall FindControlTag(TWinControl *pWCtrl, int nTag);
    void       __fastcall ChangeCurrentFormPos( void);
    AnsiString __fastcall ConvertText(const AnsiString &strCaption);
    void       __fastcall SetSelectedMenuInternal(int nTagMenu);
    void       __fastcall SetEnableAllBranche(TTreeNode *Node);
    void       __fastcall ChangeCurrentElement(CEICForm *pForm);
    TBitBtn   *__fastcall GetMenuButton(CNodeInfos *nodeinfos);
    bool       __fastcall IsSoonOf(int nTag, int nTagParent);
    int        __fastcall SelectedRealAbsoluteIndex(void);
    void       __fastcall SetInstance( HINSTANCE HInst, CTree *pTree);
    bool       __fastcall DisplayCustomSelectBtn(void);
    void       __fastcall DisableSystemButtons(void);
    CEICForm  *__fastcall GetParentForm(int nIndex);
    void       __fastcall DisplayBranche(int Tag);
    void       __fastcall CustomSelect(void);
    void       __fastcall NextItem (void);
    void       __fastcall PriorItem(void);
    void       __fastcall SetButtonAction( BUTTON_ACTION eAction, bool bEnable);
    // Fonction s'appliquant aux extra-données :
    CNodeInfos *__fastcall FindNodeEdit(int nTag);
    // Renvoie le premier numéro de Tag écran
    int         __fastcall GetFirstNode( void);
    // Renvoie le dernier numéro de Tag écran
    int         __fastcall GetLastNode ( void);
//    TDBGrid    *__fastcall GetCurrentDBList( CEICForm *pForm);
    TDBGrid    *__fastcall GetCurrentDBList( TWinControl *pWndCtrl);
    void        __fastcall SetPanelPageFooter( TPanel *pnlPageFooter);

    TCallCreateInstance __fastcall GetScreenInstanceProc(CNodeInfos *nodeinfos);
    void __fastcall EnableDisableUnderListe( CNodeInfos *parentnodeinfos, bool bTestNode);

    void __fastcall CollapseNode( CNodeInfos *nodeinfos, bool bRecurse);

    CTree *__fastcall GetParentCTree( void);

  protected:
    // Fonctions d'écriture et de lecture des données des nodes
    // dans la dfm + création d'un fichier .h de define
    virtual void __fastcall DefineProperties(TFiler* Filer);
    virtual void __fastcall ReadDatas (TStream *Stream);
    virtual void __fastcall WriteDatas(TStream *Stream);
    virtual void __fastcall GenerateHeaderFile(void);
    // Fonctions s'appliquant aux extra-données :
    // initialisation et recherche
    virtual void         __fastcall InitStandardInfos(TNodeInfos *infos);
    virtual CNodeInfos  *__fastcall FindNode(int nTag);
    virtual CNodeInfos  *__fastcall FindNode(TTreeNode *Node);
    // Fonctions lié au menu de l'application pour se déplacer
    // dans les différents écrans
    virtual void         __fastcall Next  (void);
    virtual void         __fastcall Prior (void);
    virtual void         __fastcall Return(void);
    // Fonctions utilisées lors du chargement d'un nouvel écran
    virtual void         __fastcall InitScreen(CEICForm *Form, CNodeInfos *nodeinfos, int index);
    virtual void         __fastcall DisplayButtons(TTreeNode *Node, CNodeInfos *nodeinfos);
    virtual void         __fastcall InitScreenMenu(CEICForm *Form, CNodeInfos *p_nodeinfos);
    virtual void         __fastcall LoadScreen(CEICForm **pNewForm, CNodeInfos *nodeinfos);
    virtual void         __fastcall ChangeScreen(TTreeNode **pNode);
    virtual void         __fastcall CloseForm(CEICForm *pForm);
    virtual void         __fastcall UnLoadScreens(void);
            void         __fastcall SetLoadingScreen( int nTag);
    // Fonctions évènementielles
    virtual void __fastcall OnButtonClick   ( TObject *Sender);
    virtual void __fastcall EvOnClickReturn ( TObject *Sender);
    virtual void __fastcall EvOnClickPrior  ( TObject *Sender);
    virtual void __fastcall EvOnClickNext   ( TObject *Sender);
    virtual void __fastcall EvOnClickPrint  (  TObject *Sender);
    virtual void __fastcall EvOnClickPreview( TObject *Sender);
    virtual void __fastcall EvOnDataChange  ( TObject *Sender, TField *Field);
    virtual void __fastcall EvOnCloseQuery  ( TObject *Sender, bool &CanClose);
    virtual void __fastcall EvOnChange      ( TObject *Sender, TTreeNode *Node);
    virtual void __fastcall EvOnDeletion    ( TObject *Sender, TTreeNode *Node);
    virtual void __fastcall EvOnFormKeyDown ( TObject *Sender, Word &Key, TShiftState Shift);
    virtual void __fastcall EvOnFormKeyUp   ( TObject *Sender, Word &Key, TShiftState Shift);
    virtual void __fastcall EvOnFormKeyPress( TObject* Sender, char &Key);
    virtual void __fastcall EvOnChanging    ( TObject *Sender, TTreeNode *Node, bool &AllowChange);
    virtual void __fastcall EvOnExpanding   ( TObject *Sender, TTreeNode *Node, bool &AllowExpansion);
    virtual void __fastcall EvOnCollapsing  ( TObject *Sender, TTreeNode *Node, bool &AllowCollapse );

    // Gestionnaire de message afin d'intercepter les messages clavier
    void __fastcall WMSetSelMenu ( TMessage   &Msg);
    void __fastcall WMReturn     ( TMessage   &Msg);
    void __fastcall WMPrior      ( TMessage   &Msg);
    void __fastcall WMNext       ( TMessage   &Msg);
    void __fastcall WMKeyDown    ( TWMKeyDown &Msg);
    void __fastcall WMScrSetFocus( TMessage   &Msg);
    void __fastcall WMDestroy    ( TMessage   &Msg);
    BEGIN_MESSAGE_MAP
      MESSAGE_HANDLER( WM_SETSELMENU , TMessage  , WMSetSelMenu )
      MESSAGE_HANDLER( WM_RETURN     , TMessage  , WMReturn     )
      MESSAGE_HANDLER( WM_PRIOR      , TMessage  , WMPrior      )
      MESSAGE_HANDLER( WM_NEXT       , TMessage  , WMNext       )
      MESSAGE_HANDLER( WM_KEYDOWN    , TWMKeyDown, WMKeyDown    )
      MESSAGE_HANDLER( WM_KEYUP      , TWMKeyDown, WMKeyDown    )
      MESSAGE_HANDLER( WM_SCRSETFOCUS, TMessage  , WMScrSetFocus)
      MESSAGE_HANDLER( WM_DESTROY    , TMessage  , WMDestroy    )
    END_MESSAGE_MAP(TCustomTreeView)

  public:
    // Constructeur et destructeur du composant
    __fastcall  CTree(TComponent* Owner);
    virtual __fastcall ~CTree(void);

    bool __fastcall OnCloseQueryEnCours();

    // Fonctions appelées par la fonction de base
    bool      __fastcall InitAssistant( HINSTANCE HInstance, short sMask = 0xFFFF);
    void      __fastcall ExecuteAssistant(TWinControl *pWinParent, bool bFenAssistantSeule = false);
    //int       __fastcall InsertAssistant( int nTag, CTree *pAssistant);
    int       __fastcall InsertAssistant( int nTag, int nTagBrother, CTree *pAssistant);
    void      __fastcall DeleteAssistant( int nTag, int nIndex);

    void      __fastcall SetBoldNode( bool bBold, TTreeNode *Node);
    void      __fastcall SetDrophilitedNode( bool bValue, TTreeNode *pNode);

    __property int ScreenSize = { read=m_nSizeAssist };

    //--------------------------------------------//
    // Fonctions utilisables par les utilisateurs //
    //--------------------------------------------//

    // Permet d'affecter un DataSource aux composants DB d'une CEICForm
    // à l'aide de leur numéro de Tag.
    // Si le paramètre Form est omit, la fonction utilisera
    // la CEICForm courante.
    void        __fastcall SetComponentDataSource(TDataSource *pDataSource, int nTag, CEICForm *pForm = NULL);
    // Permet de rendre visible ou de cacher un écran grâce à son
    // numéro de tag (généré dans le fichier .h du même nom que le CTree)
    void        __fastcall SetVisibleScreen(bool bVisible, int nTag);
    // Permet de griser ou de dégriser un écran grâce à son numéro de tag
    void        __fastcall SetEnableScreen(bool bEnabled, int nTag);
    // Permet de changer la ressource d'un écran en lui affectant
    // la ressource d'un autre écran
    // TagIn : tag de l'écran dont la ressource va être modifié
    // TagTo : tag de l'écran qui contient la ressource à affecter
    void        __fastcall ReplaceRessource( int nTagDst, int nTagSrc);
    // Permet de modifier le libellé d'un écran grâce à son tag
    void        __fastcall SetTextScreen(const AnsiString &strCaption, int nTag);
    AnsiString  __fastcall GetTextScreen(int nTag);
    AnsiString  __fastcall GetTextScreenComplet(int nTag);
    // Permet de modifier le level d'un écran grâce à son tag
    char __fastcall GetLevelScreen( int nTag);
    void __fastcall SetLevelScreen( int nTag, char cLevel);
    // Permet d'obtenir un pointeur sur la liste d'un écran
    // Si le paramètre Form est omit, la liste est recherché
    // depuis la fenêtre courante
    TDBGrid    *__fastcall GetDBList( CEICForm *pForm = NULL, CEICForm **pFormList = NULL);
    // Permet de forcer à afficher un écran grâce à son numéro
    // de tag. Cette fonction a le même effet que si l'utilisateur
    // va cliquer sur l'écran dans l'arbre.
    // L'écran devient l'écran courant
    void        __fastcall SetSelectedScreen(int nTag, bool bImmediately = false);
    // Renvoie l'écran parent de la Form passé en paramètre.
    // Si le Form ne possède aucun parent, elle renvoie NULL
    CEICForm   *__fastcall GetParentForm(CEICForm *Form);
    // Permet de savoir si un écran est visible ou non
    bool        __fastcall GetVisibleScreen(int tnTag);
    // Permet de savoir si un écran est grisé ou non
    bool        __fastcall GetEnableScreen(int nTag);
    // Renvoie le tag de l'écran en cours
    int         __fastcall GetSelectedScreen(void);
    // Renvoie le tag de l'écran en cours de chargement
    int         __fastcall GetLoadingScreen( void);
    // Renvoie un pointeur CEICForm sur l'écran courant
    CEICForm   *__fastcall GetCurrentForm(void);
    // Permet de recevoir un pointeur de type CEICForm d'un écran
    // grâce à son tag.
    // Si la fonction renvoie NULL, cela veut dire que l'écran
    // n'est pas actuellement chargé
    CEICForm   *__fastcall GetForm(int nTag);
    // Renvoie toutes les données d'un node
    CNodeInfos *__fastcall GetNodeExtraInfos(int Tag);
    // Développe une branche de l'arbre
    void        __fastcall ExpandNode  ( int nTag, bool bRecurse);
    // Réduit une branche de l'arbre
    void        __fastcall CollapseNode( int nTag, bool bRecurse);
    // Quitte l'assistant
    void        __fastcall ExitAssistant( void);
    // Rafraichit les boutons Print/Preview
    void        __fastcall RefreshPrintPreview( void);
    // Ajoute un bouton personnalisé
    void        __fastcall AddButtonAction( TSpeedButton *sbNew, BUTTON_ACTION eAction);

    int         __fastcall GetFirstChild( int nTagParent);
    int         __fastcall GetNextChild ( int nTagParent, int nTagChild);
    void        __fastcall FermerSplash();
    void        __fastcall GetEtatPriorNext ( BYTE &bPriorActif, BYTE &bNextActif);

    __property short Mask = { read=m_Mask };
    __property TForm **Splash = {read = m_Splash,write = m_Splash}; //Form du splash que doit fermer l'assistant


  __published:
    __property Align;
    __property Images;
    __property Items;
    __property Selected;

    __property int FirstNodeTag = { read=GetFirstNode };
    __property int LastNodeTag  = { read=GetLastNode  };

    __property bool AutoLettre  = { read=m_AutoLettre, write=m_AutoLettre, default=true };

    __property TPanel *PageFooter = { read=m_pnlPageFooter, write=SetPanelPageFooter };

    __property TNotifyEvent OnClose = { read=m_pfncOnClose, write=m_pfncOnClose };
    __property TChangingScreenEvent OnChangingScreen = { read=m_pfncOnChangingScreen, write=m_pfncOnChangingScreen };
    __property TChangeScreenEvent OnChangeScreen = { read=m_pfncOnChangeScreen, write=m_pfncOnChangeScreen };
    __property OnResize;
};
//---------------------------------------------------------------------------
class CScreenProperty : public TPropertyEditor
{
  private :
    typedef TPropertyEditor inherited;
    _di_IFormDesigner eDesigner;

  public  :
     __fastcall CScreenProperty(void);

    TPropertyAttributes __fastcall GetAttributes(void);
    virtual void __fastcall Edit(void);
    virtual AnsiString __fastcall GetValue() { return ("(Cliquez-ici)"); };
};
//---------------------------------------------------------------------------
typedef TForm *( *TCreateAssistant)( TComponent *);
typedef int __import ( *TRunMethod)( enum RUN_ACTION eAction);
typedef int __import ( *TRun2Method)( enum RUN_ACTION eAction, TForm *FenMain);
//---------------------------------------------------------------------------
enum ERROR_ASSISTANT { EA_OK,
                       EA_LOADLIBRARIE_FAIL,
                       EA_CREATEINSTANCE_FENMAINASSISTANT_NOT_FOUND,
                       EA_RUN_NOT_FOUND,
                       EA_CREATEINSTANCE_FENMAINASSISTANT_FAIL,
                       EA_TREE_NOT_FOUND,
                       EA_INITASSISTANT_FAIL,
                       EA_UNLOADLIBRARIE_FAIL };
//---------------------------------------------------------------------------
typedef struct {
  HINSTANCE   hInstance;
  TForm      *pFenMainAssistant;
  TRunMethod  pRun;
  TRun2Method pRun2;
  int         nTag;
  CTree      *pTree;
  int         nIndex;
} TDefAssistant;
//---------------------------------------------------------------------------
class PACKAGE_OUTILS CInsertAssistant
{
  private:
    TList          *m_pAssistants;
    ERROR_ASSISTANT m_eError;

    int __fastcall GetCount( void);

  public:
    __fastcall  CInsertAssistant( void);
    virtual __fastcall ~CInsertAssistant( void);

    bool __fastcall PushAssistant( CTree *pTreeAss, int nTag, int nTagBrother, const AnsiString &strFileName, int nOption, TComponent *pOwner, short sMask = 0xFFFF);
    bool __fastcall PopAssistant( void);
    bool __fastcall PopAllAssistants( void);

    __property int CountPushedAssistants = { read=GetCount };
};
//---------------------------------------------------------------------------
extern PACKAGE_OUTILS CTree *__fastcall GetActiveTree( void);
//---------------------------------------------------------------------------
#endif
